1、汉明距离，也就是两个数的位转化为一样需要执行多少次
思想：将x，y分别与1想与，比较是否相同，如果相同就不需要改动，不同就需要改动，遍历32次即可
思想二：将x^y异或一下，相同为0，相异为1，则x^y的结果中为1的位也就是不同的位，也就是需要改动的位
class Solution {
public:
    int hammingDistance(int x, int y) {
        if(x==y)
            return 0;
        int count=0;
        for(int i=0;i<31;i++)
        {
            if((x&(1<<i))!=(y&(1<<i)))
            {
                count++;
            }
        }
        return count;
    }
};

2、在一个数组中，找到任意3个和为0的三位数，但是不能重复，
思想：
第一步：排序一下，将数组变为从小到大的有序数组
第二步：遍历数组，while（i<num.size()），定义left=i+1,right=size-1,这样就是在left和right的范围内找left+right=-i的值即可，如果num[i]>0，直接退出
，如果找到了  需要注意去重，因为重复值不可以操作
class Solution {
public:
    vector<vector<int>> threeSum(vector<int>& nums) {
        vector<vector<int>> vv;
        vector<int> v;
        if(nums.size()<3)
            return vv;
        sort(nums.begin(),nums.end());//从小到大排序
        for(int i=0;i<nums.size();++i)
        {
            if(nums[i]>0)//因为是从小到大的排序，如果第一个都大于0，就没机会等于0
                return vv;
            if(i>0&&nums[i]==nums[i-1])  //去重
                continue;
            int left=i+1;
            int right=nums.size()-1;
            while(left<right)
            {
                if(nums[left]+nums[right]>-nums[i])//说明后面的值太大了，right得前一
                    right--;
                else if(nums[left]+nums[right]<-nums[i])
                    left++;
                else
                {
                    v.push_back(nums[i]);
                    v.push_back(nums[left]);
                    v.push_back(nums[right]);
                    vv.push_back(v);
                    v.clear();
                    left++;
                    right--;
                    while(left<right&&nums[left]==nums[left-1])
                        left++;
                    while(left<right&&nums[right]==nums[right+1])
                        right--; 
                }
               
            }
        }
        return vv;
    }
};

3、2数相加，有2个链表，表示2个数，但是这数是逆序的，需要将这2个数加起来，也是逆序打印
思想：将2个链表对应节点的值加起来放到数组里面，然后建立新链表，节点值即为数组中的值。
/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode() : val(0), next(nullptr) {}
 *     ListNode(int x) : val(x), next(nullptr) {}
 *     ListNode(int x, ListNode *next) : val(x), next(next) {}
 * };
 */
class Solution {
public:
    ListNode* addTwoNumbers(ListNode* l1, ListNode* l2) {
        int nextnum=0;
        ListNode* cur1=l1;
        ListNode* cur2=l2;
        int count1=0,count2=0;
        while(cur1)
        {
            cur1=cur1->next;
            count1++;
        }
        while(cur2)
        {
            cur2=cur2->next;
            count2++;
        }
        int size=count1>count2?count1:count2;
        int array[101]={0};

        for(int i=0;i<size;i++)
        {
            if(l1&&l2)
            {
                if(l1->val+l2->val+nextnum>9)
                {
                    array[i]=l1->val+l2->val+nextnum-10;
                    nextnum=1;
                }
                else
                {
                    array[i]=l1->val+l2->val+nextnum;
                    nextnum=0;
                }
                l1=l1->next;
                l2=l2->next;
            }
            else if(l1)
            {
                if(l1->val+nextnum>9)
                {
                    array[i]=l1->val+nextnum-10;
                    nextnum=1;
                }
                else
                {
                    array[i]=l1->val+nextnum;
                    nextnum=0;
                }
                l1=l1->next;
            }
            else if(l2)
            {
                if(l2->val+nextnum>9)
                {
                    array[i]=l2->val+nextnum-10;
                    nextnum=1;
                }
                else
                {
                    array[i]=l2->val+nextnum;
                    nextnum=0;
                }
                l2=l2->next;
            }
        }
        if(nextnum==1)
            array[size]=1;
        ListNode* head=nullptr;
        head=new ListNode(array[0]);
        ListNode* cur=head;
        for(int i=1;i<=size;++i)
        {
            if(i==size&&array[size]==0)
            {
                break;
            }
            else
            {
                ListNode* newnode=new ListNode(array[i]);
                cur->next=newnode;
                cur=newnode;
            }
            
        }
        return head;
    }
};